package com.ruoyi.wq.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.Condition;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.wq.domain.WqVote;
import com.ruoyi.wq.domain.WqVoteUser;
import com.ruoyi.wq.domain.vo.WqVoteUserVO;
import com.ruoyi.wq.mapper.WqVoteMapper;
import com.ruoyi.wq.mapper.WqVoteUserMapper;
import com.ruoyi.wq.service.IWqVoteUserService;

/**
 * 投票用户Service业务层处理
 * 
 * @author ruoyi
 * @date 2022-11-09
 */
@Service
public class WqVoteUserServiceImpl extends ServiceImpl<WqVoteUserMapper, WqVoteUser> implements IWqVoteUserService {
    
	@Autowired
    private WqVoteUserMapper wqVoteUserMapper;
	
	@Autowired
	private WqVoteMapper wqVoteMapper;
	
	@Autowired
	private ISysUserService sysUserService;
	
	@Autowired
	private RedisCache redisCache;

    /**
     * 查询投票用户
     * 
     * @param id 投票用户主键
     * @return 投票用户
     */
    @Override
    public WqVoteUser selectWqVoteUserById(String id)
    {
        return wqVoteUserMapper.selectWqVoteUserById(id);
    }

    /**
     * 查询投票用户列表
     * 
     * @param wqVoteUser 投票用户
     * @return 投票用户
     */
    @Override
    public List<WqVoteUser> selectWqVoteUserList(WqVoteUser wqVoteUser)
    {
        return wqVoteUserMapper.selectWqVoteUserList(wqVoteUser);
    }

    /**
     * 新增投票用户
     * 
     * @param wqVoteUser 投票用户
     * @return 结果
     */
    @Override
    public int insertWqVoteUser(WqVoteUser wqVoteUser)
    {
        wqVoteUser.setCreateTime(DateUtils.getNowDate());
        return wqVoteUserMapper.insertWqVoteUser(wqVoteUser);
    }

    /**
     * 修改投票用户
     * 
     * @param wqVoteUser 投票用户
     * @return 结果
     */
    @Override
    public int updateWqVoteUser(WqVoteUser wqVoteUser)
    {
        wqVoteUser.setUpdateTime(DateUtils.getNowDate());
        return wqVoteUserMapper.updateWqVoteUser(wqVoteUser);
    }

    /**
     * 批量删除投票用户
     * 
     * @param ids 需要删除的投票用户主键
     * @return 结果
     */
    @Override
    public int deleteWqVoteUserByIds(String[] ids)
    {
        return wqVoteUserMapper.deleteWqVoteUserByIds(ids);
    }

    /**
     * 删除投票用户信息
     * 
     * @param id 投票用户主键
     * @return 结果
     */
    @Override
    public int deleteWqVoteUserById(String id)
    {
        return wqVoteUserMapper.deleteWqVoteUserById(id);
    }

	@Override
	public void addVote(WqVoteUserVO wqVoteUser) {
		if(StringUtils.isBlank(wqVoteUser.getUid())){
			throw new ServiceException("缺少参数");
		}
		if(StringUtils.isBlank(wqVoteUser.getVoteId())){
			throw new ServiceException("请选择投票用户");
		}
		WqVote wqVote = wqVoteMapper.selectById(wqVoteUser.getVoteId());
		if(wqVote == null){
			throw new ServiceException("投票用户不存在");
		}
		Boolean hasKey = redisCache.hasKey(wqVoteUser.getUid());
		if(hasKey){
			Long uid = redisCache.incr(wqVoteUser.getUid());
			if(uid < 2){
				SysUser user = sysUserService.getById(SecurityUtils.getUserId());
				
				QueryWrapper<WqVoteUser> queryWrapper = new QueryWrapper<>();
				WqVoteUser entity = new WqVoteUser();
				entity.setVoteId(wqVoteUser.getVoteId());
				entity.setUserId(user.getUserId());
				queryWrapper.setEntity(entity);
				WqVoteUser voteUser = baseMapper.selectOne(queryWrapper);
				if(voteUser == null){
					redisCache.zincrby("voteScore", wqVoteUser.getVoteId(), 1.0);
					redisCache.hincrby("voteMapScore", wqVoteUser.getVoteId(), 1L);
					
					wqVoteUser.setUserId(user.getUserId());
					wqVoteUser.setAvatar(user.getAvatar());
					baseMapper.insert(wqVoteUser);
				}else{
					throw new ServiceException("不能重复投票");
				}
			}
			redisCache.deleteObject(wqVoteUser.getUid());
		}
	}

	@Override
	public void addBatch(WqVoteUserVO wqVoteUser) {
		if(StringUtils.isBlank(wqVoteUser.getUid())){
			throw new ServiceException("缺少参数");
		}
		if(StringUtils.isBlank(wqVoteUser.getVoteIds())){
			throw new ServiceException("请选择投票用户");
		}
		Boolean hasKey = redisCache.hasKey(wqVoteUser.getUid());
		if(hasKey){
			Long uid = redisCache.incr(wqVoteUser.getUid());
			if(uid < 2){
				String[] voteIds = wqVoteUser.getVoteIds().split(",");
				SysUser user = sysUserService.getById(SecurityUtils.getUserId());
				for(String voteId : voteIds){
					WqVote vote = wqVoteMapper.selectById(voteId);
					if(vote != null){
						QueryWrapper<WqVoteUser> queryWrapper = new QueryWrapper<>();
						WqVoteUser entity = new WqVoteUser();
						entity.setVoteId(voteId);
						entity.setUserId(user.getUserId());
						queryWrapper.setEntity(entity);
						WqVoteUser voteUser = baseMapper.selectOne(queryWrapper);
						if(voteUser == null){
							redisCache.zincrby("voteScore", voteId, 1.0);
							redisCache.hincrby("voteMapScore", voteId, 1L);
							
							voteUser = new WqVoteUser();
							voteUser.setVoteId(voteId);
							voteUser.setUserId(user.getUserId());
							voteUser.setAvatar(user.getAvatar());
							baseMapper.insert(voteUser);
						}
					}
				}
			}
			redisCache.deleteObject(wqVoteUser.getUid());
		}
	}

	@Override
	public TableDataInfo getPageList(WqVoteUser wqVoteUser) {
		IPage<WqVoteUser> page = baseMapper.selectPageList(Condition.getPage(wqVoteUser), wqVoteUser);
		List<WqVoteUser> list = page.getRecords();
		return Condition.getTableDataInfo(list, page.getTotal());
	}
}
